System of Sequential Kernel Regression Modeling for Forecasting and Prognostics

ABSTRACT

A monitoring system for determining the future operational condition of an object includes an empirical model to receive reference data that indicates the normal operational state of the object and input multi-dimensional pattern arrays. Each input pattern array has a plurality of input vectors, while each input vector represents a time point and has input values representing a plurality of parameters indicating the current condition of the object obtained from one or more first sensors at any time. The model generates estimate values that include at least one estimate vector of inferred estimate values for at least one future point in time or a plurality of second sensors being different from the one or more first sensors. The inferred estimate values are used to determine a current outcome of the object.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation of prior U.S. application Ser. No.13/186,153, entitled “System of Sequential Kernel Regression Modelingfor Forecasting and Prognostics,” filed Jul. 19, 2011, the content ofwhich is incorporated herein by reference in its entirety.

BACKGROUND OF THE INVENTION

1. Field of the Invention

The subject matter disclosed herein relates generally to the field ofkernel regression modeling used for predictive condition monitoring andprognostics of an object such as machine, system, or process, and moreparticularly to the use of multivariate models for analysis ofmeasurements of parameters to provide an assessment of the object beingmonitored.

2. Brief Description of the Related Art

Kernel regression is a form of modeling used to determine a non-linearfunction or relationship between values in a dataset and is used tomonitor machines or systems to determine the condition of the machine orsystem. One known form of kernel regression modeling is similarity-basedmodeling (SBM) disclosed by U.S. Pat. Nos. 5,764,509 and 6,181,975. ForSBM, multiple sensor signals measure physically correlated parameters ofa machine, system, or other object being monitored to provide sensordata. The parameter data may include the actual or current values fromthe signals or other calculated data whether or not based on the sensorsignals. The parameter data is then processed by an empirical model toprovide estimates of those values. The estimates are then compared tothe actual or current values to determine if a fault exists in thesystem being monitored.

More specifically, the model generates the estimates using a referencelibrary of selected historic patterns of sensor values representative ofknown operational states. These patterns are also referred to asvectors, snapshots, or observations, and include values from multiplesensors or other input data that indicate the condition of the machinebeing monitored at an instant in time. In the case of the referencevectors from the reference library, the vectors usually indicate normaloperation of the machine being monitored. The model compares the vectorfrom the current time to a number of selected learned vectors from knownstates of the reference library to estimate the current state of thesystem. Generally speaking, the current vector is compared to a matrixmade of selected vectors from the reference library to form a weightvector. In a further step, the weight vector is multiplied by the matrixto calculate a vector of estimate values. The estimate vector is thencompared to the current vector. If the estimate and actual values in thevectors are not sufficiently similar, this may indicate a fault existsin the object being monitored.

However, this kernel regression technique does not explicitly use thetime domain information in the sensor signals, and instead treat thedata in distinct and disconnected time-contemporaneous patterns whencalculating the estimates. For instance, since each current vector iscompared to the reference library vectors individually, it makes nodifference what order the current vectors are compared to the vectors ofthe reference library —each current vector will receive its owncorresponding estimate vector.

Some known models do capture time domain information within a kernelregression modeling construct. For example, complex signal decompositiontechniques convert time varying signals into frequency components asdisclosed by U.S. Pat. Nos. 6,957,172 and 7,409,320, or spectralfeatures as disclosed by U.S. Pat. No. 7,085,675. These components orfeatures are provided as individual inputs to the empirical modelingengine so that the single complex signal is represented by a pattern orvector of frequency values that occur at the same time. The empiricalmodeling engine compares the extracted component inputs (current oractual vector) against expected values to derive more information aboutthe actual signal or about the state of the system generating the timevarying signals. These methods are designed to work with a singleperiodic signal such as an acoustic or vibration signal. But even withthe system for complex signals, the time domain information is notimportant when calculating the estimates for the current vector sinceeach current vector is compared to a matrix of vectors with reference orexpected vectors regardless of the time period that the input vectorsrepresent.

BRIEF DESCRIPTION OF THE INVENTION

In one aspect, a method for determining the future operational conditionof an object includes obtaining reference data that indicates the normaloperational state of the object, and obtaining input pattern arrays.Each input pattern array has a plurality of input vectors, while eachinput vector represents a time point and has input values representing aplurality of parameters indicating the current condition of the object.At least one processor generates estimate values based on a calculationthat uses an input pattern array and the reference data to determine asimilarity measure between the input values and reference data. Theestimate values, in the form of an estimate matrix, include at least oneestimate vector of virtual or inferred estimate values, and representsat least one time point that is not represented by the input vectors.The inferred estimate values are used to determine a future condition ofthe object.

In another aspect, a monitoring system for determining the futureoperational condition of an object has an empirical model moduleconfigured to receive reference data that indicates the normaloperational state of the object, receive input pattern arrays where eachinput pattern array has a plurality of input vectors. Each input vectorrepresents a time point and has input values representing a plurality ofparameters indicating the current condition of the object. The empiricalmodel is also configured to generate estimate values based on acalculation that uses an input pattern array and the reference data todetermine a similarity measure between the input values and referencedata. The estimate values are in the form of an estimate matrix thatincludes estimate vectors of inferred estimate values, and each estimatematrix represents at least one time point that is not represented by theinput vectors. A prognostic module is configured to use the inferredestimate values to determine a future condition of the object.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a block diagram of an example arrangement of a monitoringsystem;

FIG. 2 is flow chart showing the basic process for the monitoringsystem;

FIG. 3 is a schematic diagram of the autoassociative similarity basedmodeling equation;

FIG. 4 is a schematic diagram of one form of the inferential similaritybased modeling equation;

FIG. 5 is a schematic diagram of another form of the inferentialsimilarity based modeling equation;

FIG. 6 is a schematic diagram of the autoassociative sequentialsimilarity based modeling equation;

FIG. 7 is a schematic diagram of one form of the inferential sequentialsimilarity based modeling equation that extrapolates in the modeledsensor dimension;

FIG. 8 is a schematic diagram of another form of the inferentialsequential similarity based modeling equation that extrapolates in themodeled sensor dimension;

FIG. 9 is a schematic diagram of an inferential sequential similaritybased modeling equation that extrapolates in the time dimension;

FIG. 10 is a schematic diagram of an inferential sequential similaritybased modeling equation that extrapolates in the time dimension; and

FIG. 11 is a schematic diagram of an inferential sequential similaritybased modeling equation that extrapolates in the time dimension and thesensor dimension.

DETAILED DESCRIPTION OF THE INVENTION

It has been determined that the accuracy of the estimates in a kernelregression model, and specifically a similarity based model, can besubstantially improved by incorporating time domain information into themodel. Thus, one technical effect of the present monitoring system andmethod is to generate estimate data by capturing time domain informationfrom the large numbers of periodic and non-periodic sensor signals thatmonitor industrial processes, systems, machines, or other objects. Thetechnical effect of the present system also is to operate an empiricalmodel that extends the fundamental non-linear mathematics at the core ofkernel regression modeling from a vector-to-vector operation to amatrix-to-matrix (or array-to-array) operation as explained in detailbelow. Another alternative technical effect of the monitoring system andmethod is to generate virtual or inferred estimate values for futuretime points to determine a future condition of the object beingmonitored whether the reference data used to generate the estimates isdata representing normal operation of the object being monitored orfailure mode data to better match data from the object that indicates afault.

Referring to FIG. 1, a monitoring system 10 incorporating time domaininformation can be embodied in a computer program in the form of one ormore modules and executed on one or more computers 100 and by one ormore processors 102. The computer 100 may have one or more memorystorage devices 104, whether internal or external, to hold sensor dataand/or the computer programs whether permanently or temporarily. In oneform, a standalone computer runs a program dedicated to receiving sensordata from sensors on an instrumented machine, process or other objectincluding a living being, measuring parameters (temperature, pressure,and so forth). The object being monitored, while not particularlylimited, may be one or more machines in an industrial plant, one or morevehicles, or particular machines on the vehicles such as jet engines toname a few examples. The sensor data may be transmitted through wires orwirelessly over a computer network or the internet, for example, to thecomputer or database performing the data collection. One computer withone or more processors may perform all of the monitoring tasks for allof the modules, or each task or module may have its own computer orprocessor performing the module. Thus, it will be understood thatprocessing may take place at a single location or the processing maytake place at many different locations all connected by a wired orwireless network.

Referring to FIG. 2, in the process (300) performed by the monitoringsystem 10, the system receives data or signals from sensors 12 on anobject 16 being monitored as described above. This data is arranged intoinput vectors 32 for use by the model 14. Herein, the terms input,actual, and current are used interchangeably, and the terms vector,snapshot, and observation are used interchangeably. The input vector (oractual snapshot for example) represents the operational state of themachine being monitored at a single moment in time.

Additionally, or alternatively, the input vector 32 may includecalculated data that may or may not have been calculated based on thesensor data (or raw data). This may include, for example, an averagepressure or a drop in pressure. The input vector 32 may also have valuesrepresenting other variables not represented by the sensors on theobject 16. This may be, for example, the average ambient temperature forthe day of the year the sensor data is received, and so forth.

The model 14 obtains (302) the data in the form of the vectors 32 andarranges (304) the input vectors into an input array or matrix. It willbe understood, however, that the model 14 itself may form the vectors 32from the input data, or receive the vectors from a collection or inputcomputer or processor that organizes the data into the vectors andarrays. Thus, the input data may be arranged into vector 32 by computer100, another computer near location of computer 100, or at anotherlocation such as near the object 16.

The model 14 also obtains (306) reference data in the form of referencevectors or matrices from reference library 18 and sometimes referred toas a matrix H. The library 18 may include all of the historicalreference vectors in the system. The model 14 then uses the referencedata and input arrays to generate estimates (310) in the form of aresulting estimate matrix or array. The estimate matrix is provided to adifferencing module 20 that determines (312) the difference (orresidual) between the estimate values in the estimate matrix andcorresponding input values in the input array. The residuals are thenused by an alert or analysis management module (or just alert module) 22to determine (314) if a fault exists.

As shown in dashed line, the monitoring system 10 also may have aLocalization Module 28 that changes which data from the referencelibrary is used to form (308) a subset or matrix D(t) (referred to as athree-dimensional collection of learned sequential pattern matricesbelow (FIG. 6)) to compare to the vectors in each input array.Otherwise, the matrix D(t) of reference data may remain the same for allof the input matrices as explained in detail below. Also, the monitoringsystem may have an adaption module 30 that continuously places the inputvectors into the reference library to update the data in the library orwhen a certain event occurs, such as when the model receives data thatindicates a new normal condition of the machine not experienced before,for example. This is also described in detail below.

The alert module 22 may provide alerts as well as the residuals directlyto an interface or output module 24 for a user to perform their owndiagnostic analysis, or a diagnostic module 26 may be provided toanalyze the exact nature of the cause of the fault to report diagnosticconclusions and severity ratings to the user through the output module24.

The output module 24, which may include mechanisms for displaying theseresults (for example, computer screens, PDA screens, print outs, or webserver), mechanisms for storing the results (for example, a databasewith query capability, flat file, XML file), and/or mechanisms forcommunicating the results to a remote location or to other computerprograms (for example, software interface, XML datagram, email datapacket, asynchronous message, synchronous message, FTP file, service,piped command and the like).

A more detailed explanation of the empirical model 14 requires certainknowledge of kernel regression. In pattern recognition techniques suchas kernel regression, a pattern consists of input data (as describedabove) grouped together as a vector. The data for each vector iscollected from a piece of equipment at a common point in time. Here,however, and as explained in greater detail below, the pattern (vector)of contemporaneous sensor values associated with existing kernelregression methods is augmented with temporally-related information suchas sequential patterns from successive moments in time or the outputfrom time-dependent functions (for example, filters, time-derivativesand so forth) applied to the patterns from successive moments in time.Therefore, the individual patterns (vectors) processed by traditionalkernel regression methods are replaced by temporally-related sequencesof patterns that form an array (or simply pattern arrays or patternmatrices).

All kernel-based modeling techniques, including kernel regression,radial basis functions, and similarity-based modeling can be describedby the equation:

$\begin{matrix}{x_{est} = {\sum\limits_{i = 1}^{L}{c_{i}{K\left( {x_{new},x_{i}} \right)}}}} & (1)\end{matrix}$

where a vector x_(est) of sensor signal or sensor value estimates isgenerated as a weighted sum of results of a kernel function K, whichcompares the input vector x_(new) of sensor measurements to L learnedpatterns of sensor data, x_(i). x_(i) is formed of reference or learneddata in the form of vectors (also referred to as observations, patterns,snapshots, or exemplars). The kernel function results are combinedaccording to weights which may be in the form of vectors and can bedetermined in a number of ways. The above form is an “autoassociative”form, in which all estimated output signals are also represented byinput signals. In other words, for each input value, an estimate sensorvalue is calculated. This contrasts with the “inferential” form in whichcertain estimate output values do not represent an existing input value,but are instead inferred from the inputs:

$\begin{matrix}{y_{est} = {\sum\limits_{i = 1}^{L}{c_{i}{K\left( {x_{new},x_{i}} \right)}}}} & (2)\end{matrix}$

where in this case, y_(est) is an inferred sensor estimate obtained fromthe kernel-based comparison of the input vectors x_(new) of otherparameters to the L learned exemplars x_(i) of those parameters. Eachlearned exemplar x_(i) is associated with another exemplar vector y_(i)of the parameters to be estimated, which are combined in a weightedfashion according to the kernel K and vectors c_(i) (which are functionsat least in part of the y_(i)) to predict output y_(est). In a similarfashion, more than one sensor can be simultaneously inferred.

What is common to the kernel-based estimators is the kernel function,and the generation of a result from a linear combination of exemplars(for example, a matrix of the exemplars or vectors), based on the kernelresults and the vectors c_(i) that embodies the exemplars. Kernelfunction K is a generalized inner product, but in one form has thefurther characteristic that its absolute value is maximum when x_(new)and x_(i) are identical.

According to one embodiment of the invention, a kernel-based estimatorthat can be used to provide the model is Kernel Regression, exemplifiedby the Nadaraya-Watson kernel regression form:

$\begin{matrix}{y_{est} = {\frac{\sum\limits_{i = 1}^{L}{y_{i}^{out}{K\left( {x_{new},x_{i}^{in}} \right)}}}{\sum\limits_{i = 1}^{L}{K\left( {x_{new},x_{i}^{in}} \right)}}\left( {{Inferential}\mspace{14mu} {form}} \right)}} & (3) \\{x_{est} = {\frac{\sum\limits_{i = 1}^{L}{x_{i}{K\left( {x_{new},x_{i}} \right)}}}{\sum\limits_{i = 1}^{L}{K\left( {x_{new},x_{i}} \right)}}\left( {{Autoassociative}\mspace{14mu} {form}} \right)}} & (4)\end{matrix}$

In the inferential form, a multivariate estimate of inferred parametersy_(est) is generated from the results of the kernel K operator on theinput vector of parameter measurements x_(new) and the L learnedexemplars x_(i), linearly combined according to respective learnedvectors y_(i), which are each associated with each x_(i), and normalizedby the sum of kernel results. The y_(i) represent the L sets of learnedmeasurements for the parameters in Y, which were associated with (suchas, measured contemporaneously with) the learned measurements ofparameters in X. By way of example, X may comprise a plurality ofpressure readings, while Y may represent a corresponding plurality oftemperature readings from a common system. In other words, the pressurereadings may be used to calculate weights which are then used in acalculation with y_(i) (the reference vector with previous values of themissing parameter) to calculate estimated temperature readings or sensorvalues for y_(est).

In the autoassociative form of the kernel regression, a multivariateestimate of parameters x_(est) is generated by a normalized linearcombination of the learned measurements of those parameters x_(i) (forexample, in the form of a matrix D of exemplars described below),multiplied by the kernel operation results for the input vector x_(new),vis-à-vis the learned observations x_(i).

In kernel regression for the present example, the c_(i) from equations 1and 2 above are composed of the learned exemplars normalized by the sumof the kernel comparison values. The estimate vectors, y_(est) orx_(est), comprise a set of estimated parameters that are, according toone example, differenced with actual measured values (x_(new), ory_(new), which is not input to the model in the inferential case) toprovide residuals.

In a specific example of Kernel regression, a similarity-based model(SBM) can be used as the model according to the present invention.Whereas the Nadaraya-Watson kernel regression provides estimates thatare smoothed estimates given a set of (possibly noisy) learnedexemplars, SBM provides interpolated estimates that fit the learnedexemplars when they also happen to be the input as well, such as if theinput vector is identical to one of the learned exemplars. This can beadvantageous in detecting deviations in parameters, since noise in thesesignals will be overfit to a certain extent (if noise was similarlypresent on the exemplars from which the model was made), thus removingthe noise somewhat from the residuals as compared to the Nadaraya-Watsonkernel regression approach. SBM can be understood as a form ofkernel-based estimator by rewriting the kernel function K as theoperator {circle around (×)}, and equating the set of learned exemplarsx_(i) as a matrix D with the elements of x_(i) forming the rows, and thex_(i) observations forming its columns. Then:

K _(i=1) ^(L)(x _(i) ,x _(new))=(D ^(T) {circle around (×)} x_(new))  (5)

where D has been transposed, which results in a column vector of kernelvalues, one for each observation x_(i) in D. Similarly, the comparisonof all exemplars with each other can be represented as:

K= _(i,j=1) ^(L)(x _(i) ,x _(j))=(D ^(T) {circle around (×)} D)  (6)

Then, the autoassociative form of SBM generates an estimate vectoraccording to:

x _(est) =D·(D ^(T) {circle around (×)} D)⁻¹·(D ^(T) {circle around (×)}x _(new))  (7)

where x_(est) is the estimate vector, x_(new) is the input observation,and D is a learned vector matrix comprising the set (or subset) of thelearned exemplary observations of the parameters. The similarityoperator or kernel is signified by the symbol {circle around (×)}, andhas the general property of rendering a similarity score for thecomparison of any two vectors from each of the operands. Thus, the firstterm (D^(T){circle around (×)} D) would yield a square matrix of valuesof size equal to the number of observations in D as shown in equation(6) above. The term (D^(T){circle around (×)} x_(new)) would yield avector of similarity values, one similarity value for each vector in Das shown in equation 5. This similarity operator is discussed in greaterdetail below. The equation is shown schematically on FIG. 3 and showshow each component of the equation is formed by vectors as representedby the rectangular boxes. In this example, each vector contains sensorvalues for parameters 1-5 (although this could also include othernon-sensor values as described above). It will be understood that thenumbers 1-5 indicate which parameter is being represented and not theexact sensor value. Thus, the sensor value itself will be different forthe different parts of the equation (for example, the value forparameter 1 may be different in x_(new) versus that in D versus that inx_(est)).

It will also be understood that for equation (7), time domaininformation among a group of input vectors is ignored to generateestimates. In other words, since equation (7) generates an estimatevector by using a single input vector x_(new), the order in which thevectors in a group of input vectors are analyzed to generate estimatevectors is largely unimportant. If a certain order related to time (suchas sequential) is needed later in the process to determine if a faultexists or to diagnose the particular type of fault for example, then thevectors can be ordered as desired after generating the estimates.

The estimate can further be improved by making it independent of theorigin of the data, according to the following equation, where theestimate is normalized by dividing by the sum of the “weights” createdfrom the similarity operator:

$\begin{matrix}{x_{est} = \frac{D \cdot \left( {D^{T} \otimes D} \right)^{- 1} \cdot \left( {D^{T} \otimes x_{new}} \right)}{\sum\left( {\left( {D^{T} \otimes D} \right)^{- 1} \cdot \left( {D^{T} \otimes x_{new}} \right)} \right)}} & (8)\end{matrix}$

In the inferential form of similarity-based modeling, the inferredparameters vector y_(est) is estimated from the learned observations andthe input according to:

y _(est) =D _(out)·(D _(in) ^(T) {circle around (×)} D _(in))⁻¹·(D _(in)^(T) {circle around (×)} x _(in))  (9)

where D_(in) has the same number of rows as actual sensor values (orparameters) in x_(in), and D_(out) has the same number of rows as thetotal number of parameters including the inferred parameters or sensors.Equation (9) is shown schematically on FIG. 4 to show the location ofthe vectors, the input values (1 to 5), and the resulting inferredvalues (6-7).

In one form, the matrix of learned exemplars D_(a) can be understood asan aggregate matrix containing both the rows that map to the sensorvalues in the input vector xi. and rows that map to the inferredsensors:

$\begin{matrix}{D_{a} = \left\lbrack \frac{D_{in}}{D_{out}} \right\rbrack} & (10)\end{matrix}$

Normalizing as before using the sum of the weights:

$\begin{matrix}{y_{est} = \frac{D_{out} \cdot \left( {D_{in}^{T} \otimes D_{in}} \right)^{- 1} \cdot \left( {D_{in}^{T} \otimes x_{in}} \right)}{\sum\left( {\left( {D_{in}^{T} \otimes D_{in}} \right)^{- 1} \cdot \left( {D_{in}^{T} \otimes x_{in}} \right)} \right)}} & (11)\end{matrix}$

It should be noted that by replacing D_(out) with the full matrix ofleaned exemplars D_(a), similarity-based modeling can simultaneouslycalculate estimates for the input sensors (autoassociative form) and theinferred sensors (inferential form):

$\begin{matrix}{\left\lbrack \frac{x_{est}}{y_{est}} \right\rbrack = \frac{D_{a} \cdot \left( {D_{in}^{T} \otimes D_{in}} \right)^{- 1} \cdot \left( {D_{in}^{T} \otimes x_{in}} \right)}{\sum\left( {\left( {D_{in}^{T} \otimes D_{in}} \right)^{- 1} \cdot \left( {D_{in}^{T} \otimes x_{in}} \right)} \right)}} & (12)\end{matrix}$

Referring to FIG. 5, Equation (12) uses the matrix D_(a) with referencevalues for both the input and inferred values. This results in anestimate vector with both representative input values and inferredvalues.

Yet another kernel-based modeling technique similar to the above is thetechnique of radial basis functions. Based on neurological structures,radial basis functions make use of receptive fields, in a special formof a neural network, where each basis function forms a receptive fieldin the n-dimensional space of the input vectors, and is represented by ahidden layer node in a neural network. The receptive field has the formof the kernels described above, where the “center” of the receptivefield is the exemplar that particular hidden unit represents. There areas many hidden unit receptive fields as there are exemplars. Themultivariate input observation enters the input layer, which is fullyconnected with the hidden layer. Thus, each hidden unit receives thefull multivariate input observation, and produces a result that ismaximum when the input matches the “center” of the receptive field, anddiminishes as they become increasingly different (akin to SBM describedabove). The output of the hidden layer of receptive field nodes iscombined according to weights c_(i) (as above in equation 1).

As mentioned above, the kernel can be chosen from a variety of possiblekernels, and in one form is selected such that it returns a value (orsimilarity score) for the comparison of two identical vectors that has amaximum absolute value of all values returned by that kernel. Whileseveral examples are provided herein, they are not meant to limit thescope of the invention. Following are examples of kernels/similarityoperators that may be used according to the invention for the comparisonof any two vectors x_(a) and x_(b).

$\begin{matrix}{{K_{h}\left( {x_{a},x_{b}} \right)} = e^{\frac{{{x_{a} - x_{b}}}^{2}}{h}}} & (13) \\{{K_{h}\left( {x_{a},x_{b}} \right)} = \left( {1 + \frac{{{x_{a} - x_{b}}}^{\lambda}}{h}} \right)^{- 1}} & (14) \\{{K_{h}\left( {x_{a},x_{b}} \right)} = {1 - \frac{{{x_{a} - x_{b}}}^{\lambda}}{h}}} & (15)\end{matrix}$

In equations 13-15, the vector difference, or “norm”, of the two vectorsis used; generally this is the 2-norm, but could also be the 1-norm orp-norm. The parameter h is generally a constant that is often called the“bandwidth” of the kernel, and affects the size of the “field” overwhich each exemplar returns a significant result. The power λ may alsobe used, but can be set equal to one. It is possible to employ adifferent h and λ for each exemplar x_(i). By one approach, when usingkernels employing the vector difference or norm, the measured datashould first be normalized to a range of 0 to 1 (or other selectedrange), for example, by adding to or subtracting from all sensor valuesthe value of the minimum reading of that sensor data set, and thendividing all results by the range for that sensor. Alternatively, thedata can be normalized by converting it to zero-centered mean data witha standard deviation set to one (or some other constant). Furthermore, akernel/similarity operator according to the invention can also bedefined in terms of the elements of the observations, that is, asimilarity is determined in each dimension of the vectors, and thoseindividual elemental similarities are combined in some fashion toprovide an overall vector similarity. Typically, this may be as simpleas averaging the elemental similarities for the kernel comparison of anytwo vectors x and y:

$\begin{matrix}{{K\left( {x,y} \right)} = {\frac{1}{L}{\sum\limits_{m = 1}^{L}\; {K\left( {x_{m},y_{m}} \right)}}}} & (16)\end{matrix}$

Then, elemental similarity operators that may be used according to theinvention include, without limitation:

$\begin{matrix}{{K_{h}\left( {x_{m},y_{m}} \right)} = e^{\frac{- {{x_{m} - y_{m}}}^{2}}{h}}} & (17) \\{{K_{h}\left( {x_{m},y_{m}} \right)} - \left( {1 + \frac{{{x_{m} - y_{m}}}^{\lambda}}{h}} \right)^{- 1}} & (18) \\{{K_{h}\left( {x_{m},y_{m}} \right)} = {1 - \frac{- {{x_{m} - y_{m}}}^{\lambda}}{h}}} & (19)\end{matrix}$

The bandwidth h may be selected in the case of elemental kernels such asthose shown above, to be some kind of measure of the expected range ofthe mth parameter of the observation vectors. This could be determined,for example, by finding the difference between the maximum value andminimum value of a parameter across all exemplars. Alternatively, it canbe set using domain knowledge irrespective of the data present in theexemplars or reference vectors. Furthermore, it should be noted withrespect to both the vector and elemental kernels that use a differencefunction, if the difference divided by the bandwidth is greater than 1,it can be set equal to one, resulting in a kernel value of zero forequations 14, 15, 18 and 19, for example. Also, it can readily be seenthat the kernel or similarity operator can be modified by the additionor multiplication of different constants, in place of one, h, λ, and soon. Trigonometric functions may also be used, for example:

$\begin{matrix}{{K_{h}\left( {x_{m},y_{m}} \right)} = \left( {1 + {\sin \left( {\frac{\pi}{2\; h}{{x_{m} - y_{m}}}} \right)}} \right)^{- 1}} & (20)\end{matrix}$

In one form, the similarity operator or kernel generally provides asimilarity score for the comparison of two identically-dimensionedvectors, which similarity score:

-   -   1. Lies in a scalar range, the range being bounded at each end;    -   2. Has a value of one (or other selected value) at one of the        bounded ends, if the two vectors are identical;    -   3. Changes monotonically over the scalar range; and    -   4. Has an absolute value that increases as the two vectors        approach being identical.

All of the above methods for modeling use the aforementionedkernel-based approach and use a reference library of the exemplars. Theexemplars (also called reference observations or reference vectors)represent “normal” behavior of the modeled system. Optionally, theavailable reference data can be down-selected to provide acharacteristic subset to serve as the library of exemplars, in whichcase a number of techniques for “training” the kernel-based model can beemployed. In this case, the down-selected library itself may form thematrix D used in the equations above. According to one training method,at least those observations are included in the library that have ahighest or lowest value for a given parameter across all availablereference observations. This can be supplemented with a random selectionof additional observations, or a selection chosen to faithfullyrepresent the scatter or clustering of the data. Alternatively, thereference data may be clustered, and representative “centroids” of theclusters formed as new, artificially generated exemplars, which thenform the library. A wide variety of techniques are known in the art forselecting the observations to comprise the library of exemplars. Thus,at least in general terms for this case, the matrix D remains the samein equation (7) for all of the input vectors x_(in) unless the libraryis changed (i.e. such as when the library is updated).

In an alternative arrangement for both the inferential andautoassociative forms of the empirical kernel-based model, matrix D canbe reconfigured for each input vector x_(in) so that the model can begenerated “on-the-fly” based on qualities of the input observation, anddrawing from a large set of learned observations, i.e., a reference set.One example of this is described in U.S. Pat. No. 7,403,869. Thisprocess is called localization. Accordingly, the inferential andautoassociative forms of kernel-based modeling can be carried out usinga set of learned observations x_(i) (matrix D) that are selected from alarger set of reference observations, based on the input observation.Kernel-based models are exceptionally well suited for this kind oflocalization because they are trained in one pass and can be updatedrapidly. Advantageously, by drawing on a large set of candidateexemplars, but selecting a subset with each new input observation forpurposes of generating the estimate, the speed of the modelingcalculation can be reduced and the robustness of the model improved,while still well characterizing the dynamics of the system beingmodeled.

For the monitoring system 10, the localization module 28 can use avariety of criteria to constitute the localized matrix membership forcollection D(t), including the application of the similarity operatoritself. In general, however, the input observation 32, comprising theset of parameters or derived features that are to be estimated by themodel as part of the monitoring process, are provided to thelocalization module 28, which accesses a large store of exemplarobservations in the form of reference library 18, in order to select asubset of those exemplar observations to build the model. Localizationmodule 28 selects exemplars from library 18 that are relevant to theinput observation 32, which can be a much smaller set than the size ofthe library. By way of example, the reference library 18 might comprise100,000 exemplar observations that characterize the normal dynamics ofthe system represented by the parameters being modeled, but thelocalization module 28 might select only a few dozen observations tobuild a localized model in response to receiving the input observation32. The selected exemplar observations are then provided to the nowlocalized model 14. In the vector-based system, these observations thencomprise the set of learned exemplars x_(i) for purposes of thekernel-based estimator (also shown as D in connection with SBM above).The estimate observation x_(est) is then generated accordingly asdescribed above. For the monitoring system 10, the selected learnedexemplars each may represent a vector at time point t_(p), such that asequential pattern matrix is built for each vector at t_(p) to form thecollection D(t) described below. As the next input observation 32 ispresented to the monitoring system 10, the process is repeated, withselection of a new and possibly different subset of exemplars fromlibrary 18, based on the new input observation.

According to one approach, the input observation 32 can be compared tothe reference library 18 of learned observations, on the basis of aclustering technique. Accordingly, the exemplar observations in library18 are clustered using any of a number of techniques known in the artfor clustering vectors, and the localization module 28 identifies whichcluster the input observation 32 is closest to, and selects the memberexemplars of that cluster to be the localized observations provided tothe localized model 14. Suitable clustering methods include k-means andfuzzy c-means clustering, or a self-organizing map neural network.

According to another approach, a kernel can be used to compare the inputobservation 32 to each exemplar in the library 18 to yield a similarityvalue that provides a ranking of the reference observations vis-à-visthe input observation. Then, a certain top fraction of them can beincluded in the localized collection D(t). As a further refinement ofthis localization aspect, observations in the ranked list of allreference observations are included in localized collection D(t) to theextent one of their component elements provides a value that “brackets”the corresponding value in the input vector. For example, a search downthe ranked list is performed until values in the input vector arebracketed on both the low and high side by a value in one of thereference observations. These “bracketing” observations are thenincluded in localized collection D(t) even if other observations inlibrary 18 have higher similarity to the input. The search continuesuntil all input values in the input vector are bracketed, until auser-selectable maximum limit of vectors for building sequential patternmatrices to include in collection D(t) is reached, or until there are nofurther reference observations that have sufficiently high similarity tothe input to surpass a similarity threshold for inclusion.

Other modifications in determining the membership of localizedcollection D(t) are contemplated. By way of example, in both theclustering selection method and the similarity selection methoddescribed above, the set of elements, i.e., parameters used to comprisethe vectors that are clustered or compared with the kernel forsimilarity, may not be identical to those used to generate the model andthe estimate, but may instead be a subset, or be a partially overlappingset of parameters. As mentioned above, an additional step for the system10 and model 14 is then performed to generate the collection D(t).Specifically, once the vectors (referred to as primary vectors t_(p))are selected for inclusion in collection D(t), other temporally relatedvectors (whether looking forward or looking back in time) are selectedfor each primary vector to form a learned sequential pattern matrix foreach primary vector and included in the collection D(t). The process forchoosing the temporally related vectors is explained below. It will beunderstood that the localization by the module 28 can be applied to anyof the three-dimensional collections of learned sequential patternmatrices described in detail below.

Turning now to the incorporation of the time domain information into themodel 14, by one approach for the monitoring system 10 described herein,the above kernel function, which operates to compare the similarity oftwo vectors, is replaced by an extended kernel function K that operateson two identically-dimensioned arrays:

(

_(new),

_(i))  (20)

where X_(new) is an input pattern array and X_(i) is a learned patternarray. A pattern array or pattern matrix is composed of a sequence oftemporally-related vectors, where each of its constituent vectorscontains sensor measurements from a distinct moment in time. One of thevectors in a pattern array is designated the primary vector, and thetime at which its data is derived is designated the current primary timepoint t_(p). The other vectors are associated with time points thatrelate to the primary time point in a systematic manner.

In one form, the primary time point is the most recent of the timepoints that compose a sequence of the time-ordered points (ortime-ordered vectors that represent those time points) in the patternarray. By one approach, the other time points are equally-spaced andprecede the primary time point by integer multiples of a time step Δtproviding uniform time intervals between the time points. For a givennumber of samples n_(1b), the time points form an ordered sequence:(t_(p)−n_(1b)Δt, t_(p)−(n_(1b)−1)Δt, t_(p)−2Δt, t_(p)−Δt, t_(p)). Thesequence of time points defines a look-back pattern array,

(t _(p))=[x(t _(p) −n _(1b) Δt),x(t _(p)−(n _(1b)−1)Δt), . . . x(t_(p)−2Δt),x(t _(p) −Δt),x(t _(p))]  (21)

As shown in FIG. 6, the primary vector t_(p) is positioned as theright-most column of each pattern array, and the other (n_(1b)) datavectors are column vectors that are located to the left of the primaryvector t_(p). The rows of the pattern arrays correspond to shortsegments of the time-varying signals from the modeled sensors.

By using look-back pattern arrays, the extended kernel function inequation (20) can be applied to real-time system monitoring. The primaryvector t_(p) (which means the vector at time point t_(p)) in the inputpattern array X_(new) contains system data from the current point intime, and the remainder of the array consists of data vectors fromrecent time points in the past. Thus, not only does the input patternarray contain the current, albeit static, vector used by traditionalkernel methods, but it also contains a sequence of vectors that expressthe developing, dynamic behavior of the monitored system. As system timeprogresses, new input pattern arrays are formed which contain much ofthe same data as preceding arrays except that new primary vectors appearin the right-most position of the arrays, and the oldest vectors aredropped from the left-most position. Thus, a single input vectorrepresenting a single instant in time will be used in multiple inputpattern arrays X_(new), and assuming the vectors are used in sequence,the vectors will be used the same number of times as there are vectorsin the array. In this manner, the input pattern array describes a movingwindow of patterns through time. Here, moving window means a set orgroup of a fixed number of vectors in chronological order that changeswhich vectors are included in the set as the window moves along thetimeline or along a sequence of time-ordered sensor value vectors.

The pattern array defined in equation (21) above contains n_(1b) datavectors that span a window in time equal to n_(1b)*Δt. The data vectorsare equally-spaced in time for this example. Another way to say this isthat each input pattern array or matrix is defined only by uniform timeintervals between time points represented by the input vectors withinthe input pattern array X_(new).

Alternatively, a kernel can be used to compare pattern arrays that spandiffering lengths of time. If a pattern array contains data from timepoints that are spaced by one time step Δt₁ (say one second apart forexample), and if the time points of another pattern array differ by asecond time step Δt₂ (say ten seconds apart for example), then thepattern arrays will span two differing time windows: n_(1b)*Δt₁ andn_(1b)*Δt₂ so that there are two pattern arrays that represent differentdurations. In one form, as long as the pattern arrays contain the samenumber of vectors even though one pattern array may have different timeintervals between the vectors (or time points) than in another patternarray, a kernel function that matches vectors from the same positions inthe two pattern arrays (such as right-most with right-most, second fromright with second from right, and onto left-most with left-most) will becapable of operating across varying time scales. Thus, in one example,the matrices may extend across differently spaced time points so thatthe time interval spacing could correspond to the harmonics (1/f) of thepeaks in a spectral time signal. It also will be understood that thisdifference in time period or duration covered by the pattern arrays maybe used between the learned pattern arrays and input pattern arrays,from input pattern array to input pattern array, from learned patternarray to learned pattern array, or any combination of these as long aseach vector in the input pattern array has a corresponding learnedexemplar in the learned pattern arrays (or in other words, both learnedand input matrices have the same number of vectors).

According to another example, a kernel can be used to compare patternarrays whose pattern vectors are not equally-spaced in time. Instead ofspacing pattern vectors by a constant time interval or step, the timestep can vary by position within the pattern array. By using small timesteps for most recent vectors (positioned near the right side of thearray) and larger time steps for the older vectors (positioned near theleft side of the array), the kernel function will focus attention on themost recent changes while still retaining some effect from changes inthe more distant past.

Referring again to FIG. 1, an additional filtering step may be performedon the pattern arrays by a filter module 106 prior to analysis by thekernel function (equation (21)). When the filtering is used, it isperformed on both the reference vectors and the input vectors to avoidany substantial, unintentional mismatch between the two resulting signalvalues to be used for generating estimates. In the filtering step, eachof the time-varying sensor segments (rows of a pattern array) areprocessed by a filtering algorithm to either smooth the data in thesegment or to calculate statistical features from the data. Smoothingalgorithms, such as moving window averaging, cubic spline filtering, orSavitsky-Golay filtering, capture important trends in the originalsignal, but reduce the noise in the signal. Since smoothing algorithmsproduce smoothed values for each of the elements in the input signal,they produce a pattern array that has the same dimensions as theoriginal pattern array of sensor data. Alternately, the filtering stepcan consist of the application of one or more feature extractionalgorithms to calculate statistical features of the data in each signal.These features may include the mean, variance, or time derivatives ofthe signal data. As long as the same number of feature extractionalgorithms is applied to the data in the pattern arrays, the number ofdata vectors in the original pattern array can vary.

As described above, there are numerous methods in which pattern arraysare used to represent temporal information from the system beingmodeled. These methods include, but are not limited to, sequences ofdata vectors from equally-spaced time points, sequences of data vectorsthat span differing time periods such that the pattern arrays havevarying durations, and sequences whose data vectors are notequally-spaced in time. The input pattern array may have differentintervals than the reference pattern arrays, or they may be the same. Inaddition, the pattern sequences can be filtered by smoothing or featureextraction algorithms. The only limitation on the form of the patternarrays or the arrays produced by filtering algorithms are that the twoarrays processed by the extended kernel function (equation 20) beidentically-dimensioned (i.e., having the same number of rows andcolumns).

Similar to the vector-based kernel function described above, theextended kernel function returns a scalar value or similarity measure,although here, the scalar value represents the similarity between twoarrays rather than two vectors. The extended kernel function produces asimilarity score that displays the same properties as the vector-basedkernel function enumerated above. Namely, the similarity score is ascalar whose range is bounded; has a value of one (or other selectedvalue) for one of the bounds when the two arrays are identical; variesmonotonically over the range; and whose absolute value increases as thetwo arrays approach being identical. In addition, the extended kernelfunction operates on the matching temporal components of the two arrays.This means, for the example of two look-back pattern arrays, that theextended kernel function finds the similarity between the two primaryvectors t_(p) from the reference and input pattern arrays respectively,then on the two data vectors to the left of the primary vectors −1, andso forth across the preceding vectors in the arrays.

One example of an extended kernel function is based on the similarityoperator described in U.S. Pat. No. 6,952,662. Letting X_(new) and X_(i)be two identically-dimensioned pattern arrays, containing data fromn_(sens) sensors (or parameters) and spanning n_(1b) sequential timepoints, the extended kernel function is written as follows:

$\begin{matrix}{{S\left( {{\overset{\;}{\overset{\leftrightarrow}{X}}}_{new},{\overset{\leftrightarrow}{X}}_{i}} \right)} = \frac{1}{1 + {\frac{1}{\rho}\left( {\frac{1}{n_{sens}\;}{\sum\limits_{j = 1}^{n_{sens}}\; {\theta_{j}(t)}}} \right)^{\lambda}}}} & (22)\end{matrix}$

where ρ and λ are constants. The time-dependent function θ(t) inequation 22 operates on the temporal elements of the pattern arrays,matching data from the same time point vectors in the two arrays. Onemeans of accomplishing this temporal data matching is to use a weightedaverage of the temporal data for a given sensor j:

$\begin{matrix}{{\theta_{j}(t)} = {\left\lbrack {\sum\limits_{k = 1}^{n_{lb}}\; \left( {W_{k}s_{j,k}} \right)} \right\rbrack/{\sum\limits_{k = 1}^{n_{lb}}\; W_{k}}}} & (23)\end{matrix}$

The similarity (s_(j,k)) between data elements for a given sensor j isdefined as the absolute difference of the data elements normalized bythe range of normal operating data for a sensor range_(j). Thus, thetime-dependent similarity function θ(t) for a given sensor's data is:

$\begin{matrix}{{\theta_{j}(t)} = {\left\lbrack {\sum\limits_{k = 1}^{n_{lb}}\left( \frac{{W_{k}{}{\overset{\leftrightarrow}{X}}_{{{new};j},k}} - {\overset{\leftrightarrow}{X}}_{{i;j},k}}{{range}_{j}} \right)} \right\rbrack/{\sum\limits_{k = 1}^{n_{lb}}W_{k}}}} & (24)\end{matrix}$

Combining equations 22 and 24, produces an extended kernel function fortwo pattern arrays:

$\begin{matrix}{{S\left( {{\overset{\leftrightarrow}{X}}_{new},{\overset{\leftrightarrow}{X}}_{i}} \right)} = \frac{1}{1 + {\frac{1}{\rho}\left\lbrack {\frac{1}{n_{sens}}{\sum\limits_{j = 1}^{n_{sens}}\left( \frac{\sum\limits_{k = 1}^{n_{lb}}\left( \frac{W_{k}{{{\overset{\leftrightarrow}{X}}_{{{new};j},k} - {\overset{\leftrightarrow}{X}}_{{i;j},k}}}}{{range}_{j}} \right)}{\sum\limits_{k = 1}^{n_{lb}}W_{k}} \right)}} \right\rbrack}^{\lambda}}} & (25)\end{matrix}$

Another example of an extended kernel function is based on thesimilarity operator described in U.S. Pat. No. 7,373,283. Again lettingX_(new) and X_(i) be two identically-dimensioned pattern arrays,containing data from n_(sens) sensors and spanning n_(1b) sequentialtime points, this second extended kernel function is written as follows:

$\begin{matrix}{{S\left( {{\overset{\leftrightarrow}{X}}_{new},{\overset{\leftrightarrow}{X}}_{i}} \right)} = {\frac{1}{n_{sens}}{\sum\limits_{j = 1}^{n_{sens}}\left\lbrack \frac{1}{1 + {\frac{1}{\rho}\left( {\theta_{j}(t)} \right)^{\lambda}}} \right\rbrack}}} & (26)\end{matrix}$

This extended kernel function utilizes the same time-dependent functionθ(t) as defined by equations 23 and 24 to compare the temporal data of agiven sensor in the two pattern matrices:

$\begin{matrix}{{S\left( {{\overset{\leftrightarrow}{X}}_{new},{\overset{\leftrightarrow}{X}}_{i}} \right)} = {\frac{1}{n_{sens}}{\sum\limits_{j = 1}^{n_{sens}}\left\lbrack \frac{1}{1 + {\frac{1}{\rho}\left( \frac{\sum\limits_{k = 1}^{n_{lb}}\left( \frac{W_{k}{{{\overset{\leftrightarrow}{X}}_{{{new};j},k} - {\overset{\leftrightarrow}{X}}_{{i;j},k}}}}{{range}_{j}} \right)}{\sum\limits_{k = 1}^{n_{lb}}W_{k}} \right)^{\lambda}}} \right\rbrack}}} & (27)\end{matrix}$

While referring to FIG. 6, the two extended kernel functions (equations25 and 27) differ only in how they aggregate information from themodeled sensors, with the first equation representing the elemental formof a kernel function, and the second equation representing the vectordifference form (such as 1-norm) of a kernel function. Both equationsutilize weighted averaging to account for differences between thesegments of time-varying signals in the two arrays X_(new) and X_(i).Specifically, for both example equations 25 and 27, and for eachsequential learned pattern matrix a to g, the absolute difference iscalculated for each corresponding pair of learned and input values. Thevalues correspond when they represent (1) the same sensor (or parameter)and (2) either the same time point within the pattern array (such asboth values being from the primary time t_(p)) or the same positionrelative to the other vectors in the array (such as when both values areon vectors that are second from the right within the pattern array). Theabsolute differences from the pairs of learned and input values arecombined via weighted averaging to obtain a resulting single averagevalue for the particular sensor. This is repeated for each sensor orparameter (1 to 5) represented by the pattern matrices a to g andpattern arrays X_(new) so that there is one resulting average scalar foreach sensor/parameter in the weighted averaging step.

Then, in the first extended kernel function (equation 25), the resultsfrom the weighted averaging step are in turn averaged across all sensorsto produce a scalar value for the array-to-array comparison. Finally,this scalar value is transformed into a value that adheres to theproperties of a similarity score as described above so that it fallswithin a range of zero to one for example, with one meaning identical.This process is then repeated for each learned sequential pattern matrixa to g in the three-dimensional collection D(t). In the second extendedkernel function (equation 27), the results from the weighted averagingstep are converted into similarity scores right away, one for eachsensor. Then this vector of similarity scores is averaged so that asingle similarity score is returned by the function for each learnedsequential pattern matrix a to g in the three-dimensional collectionD(t).

When used within context of similarity-based modeling, the extendedkernel functions described above can also be termed extended similarityoperators without loss of generality. The notation used in the aboveequations (S(X_(new),X_(i))) can also be written using the traditionalsimilarity operator symbol (X_(new){circle around (×)} X_(i)).

Extended versions of other vector-based kernel functions defined above(for example, equations 13 through 20) can be constructed by usingweighted averaging to match temporal data from the same time points intwo sequential pattern arrays. For instance, letting X_(new) and X_(i)be two identically-dimensioned pattern arrays, containing data fromn_(sens) sensors and spanning n_(1b) sequential time points, an extendedversion of the kernel function defined in equation 16, using theelemental similarity operator of equation 17, is:

$\begin{matrix}{{K_{h}\left( {{\overset{\leftrightarrow}{X}}_{new},{\overset{\leftrightarrow}{X}}_{i}} \right)} = {\frac{1}{n_{sens}}{\sum\limits_{j = 1}^{n_{sens}}\left\lbrack {\exp \left( {- {\frac{1}{h}\left\lbrack \frac{\sum\limits_{k = 1}^{n_{lb}}{W_{k}{{{\overset{\leftrightarrow}{X}}_{{{new};j},k} - {\overset{\leftrightarrow}{X}}_{{i;j},k}}}}}{\sum\limits_{k = 1}^{n_{lb}}W_{k}} \right\rbrack}^{2}} \right)} \right\rbrack}}} & (28)\end{matrix}$

Weighted averaging (equation 22) is used to account for differencesbetween segments of the time-varying signals in pattern arrays since theweights can be selected such that more recent data are more heavilyweighted than outdated data. Thus, data from the primary time pointt_(p) are typically given the highest weight, with data from precedingtime points (equation 21) given ever-decreasing weights. Numerousschemes can be used to define the weights, such as having them declinelinearly or exponentially with time relative to the primary time point.

It will be understood that various other time-dependent functions θ(t)can be used to match data from sequential time points in two segments oftime-varying signals. Such methods include, but are not limited to,other weighted norms (2-norm and p-norm) and maximum, minimum, or mediandifference. All that is required of the function is that it returns ascalar value that is minimized (a value of 0) if the two sequences areidentical and increases in value as the sequences become more different.

In order to combine the concept of sequential pattern arrays with anextended similarity operator (for example, equation 25 or 27) in theautoassociative form of SBM (equation 7), the concept of thevector-based learned vector matrix D is extended. In the standard formof SBM described above, the learned vector matrix consists of a set oflearned exemplars (vectors) selected from various points in time duringperiods of normal operation. Letting the time points from which thesevectors are selected represent primary time points, each learned vectorcan be expanded into a learned sequential pattern matrix by collectingdata from a sequence of time points that precede each primary timepoint. In this manner, the learned vector matrix D is expanded into acollection of learned sequential pattern matrices D(t). This collectionof learned pattern matrices forms a three-dimensional matrix, whereinthe dimensions represent the modeled sensors or parameters in a firstdimension, the learned exemplars (vectors) from various primary timepoints in a second dimension, and time relative to the primary timepoints in a third dimension.

The training methods described above that are used for constructing thelearned vector matrix used in vector-based forms of SBM can be utilizedto create the three-dimensional collection of learned sequential patternmatrices D(t) required by the sequential pattern forms of SBM. This isaccomplished by augmenting each reference vector selected by a trainingalgorithm with reference vectors from preceding time points to constructa sequential pattern matrix. The collection of learned pattern matrices,one for each reference vector selected by a training algorithm, is drawnfrom reference library 18 of exemplars which represents “normal”behavior of the modeled system. If the time-inferential form ofsequential SBM (described below) is used, then additional vectors fromsucceeding time points are added to each sequential pattern matrix.

The training methods that are used for the vector-based forms of SBMselect exemplars (vectors) from various points in time during periods ofnormal operation, without regard to the time domain information inherentin the reference data. In the sequential pattern array forms of SBM,that time domain information is supplied by augmenting each of theselected exemplars with data vectors from a sequence of time points thatimmediately precede and (possibly) succeed the primary time points. Inan alternative process for building and localizing the collection D(t)of sequential learned pattern matrices while factoring in the timedomain information, each input pattern array may be compared to everysequence of reference vectors that is equal in number (namely, n_(1b)+1)to that in the input pattern array. The comparison is accomplished byusing an extended form of the similarity operator (for example, equation25 or 27) to identify those sequences of reference vectors that are mostsimilar to the input pattern array. Each of the identified sequences ofreference vectors forms one of the sequential learned pattern matricesin the collection D(t). Whatever the selection process, it is possiblefor a training method to select exemplars from primary time points thatare quite near to one another. When two exemplars are selected fromnearby primary time points, the corresponding sequential patternmatrices may contain data vectors in common.

Referring to FIG. 6, equation 7 is shown with an input pattern arrayX_(new) and a three-dimensional collection of learned sequential patternmatrices D(t). The input pattern array X_(new) may also be referred toas the current or actual pattern array or matrix since it includes thevector t_(p) representing a current instant in time, and in contrast tothe learned pattern matrices in D(t). In the illustrated example, theinput pattern array X_(new) includes four vectors where vector t_(p) isthe last (right-most) vector in the array. The other vectors arenumbered as −3 to −1 referring to the number of time intervals beforet_(p) for simplicity. Thus, it will be understood that vector −3 on FIG.6 represents the same thing as (t_(p)−n_(1b)Δt) where n_(1b)=3. As shownin FIG. 6, the three dimensions of the collection of learned sequentialpattern matrices (modeled sensors, primary time points, and patternsequences) are depicted as follows: the numbers 1 through 5 representdata from five modeled sensors, the four columns (or vectors) of numbersrepresent four sequential time points, and the seven layered rectangleseach represent a sequential pattern matrix a to g each with a primarytime point t_(p) selected from various periods of normal operation. Thethree-dimensional collection of learned sequential pattern matrices D(t)contains the seven sequential pattern matrices a to g. Thus, eachsequential pattern matrix a to g comprises data from five sensors andfour sequential points in time, and has the same dimensions as the inputpattern matrix X_(new). For comparison, another way to visualize thedifference between the prior vector-based equation with atwo-dimensional matrix D (FIG. 3) and the three-dimensional collectionof learned sequential pattern matrices D(t) (FIG. 6) is that the priortwo-dimensional array would merely have been formed by a single matrixcutting across the seven sequential pattern arrays a to g to includeonly the t_(p) vectors from the three-dimensional collection D(t).

In the right-most bracket in FIG. 6, the extended similarity operator({circle around (×)}) calculates the similarity between the inputpattern array X_(new) and the seven learned sequential pattern matricesa to g as explained above. In the example of FIG. 6, and using theweighted averaging step from equations 25 or 27, the model compares thetime-varying signal for sensor 1 in sequential pattern matrix a to thetime-varying signal for sensor 1 in the input pattern array X_(new) toobtain a single average value for sensor 1. This is repeated for sensors2-5 until one average value is provided for each sensor. Then, thesescalar values (or similarity scores for equation 27) are averaged todetermine a single similarity measure for sequential pattern matrix a.This is then repeated for each sequential pattern matrix b to g,returning a similarity vector containing seven similarity scores, onesimilarity score for each learned sequential pattern matrix a to g.

The operation in the middle bracket produces a seven-by-seven squaresimilarity matrix of similarity values, one for each combination of apair of learned sequential pattern matrices a to g in collection D(t).Multiplication of the inverse of the resulting similarity matrix withthe similarity vector produces a weight vector containing sevenelements. In a final step, the weight vector is multiplied by thecollection D(t) to create an estimate matrix X_(est). In one form, theestimate matrix X_(est) is the same size as the input pattern arrayX_(new) so that it has an estimate vector that corresponds to each ofthe time periods represented by the input vectors in the input patternarrays. In the present example of FIG. 6, the estimate matrix X_(est)has an estimate vector for the current moment in time t_(p) and for eachof the three preceding time points −1 to −3 as if formed in a look-backwindow. The use of the estimate matrix X_(est) is described in furtherdetail below. It also should be noted that the preceding vectors groupedtogether with or without the current or primary vector may be called alook-back window anywhere herein, and the succeeding vectors groupedtogether with or without the current or primary vector may be called alook-ahead window explained below and anywhere herein.

Extensions to the inferential form of SBM (equation 9) that utilizesequential pattern matrices with an extended similarity operator arereadily apparent. Analogous to the vector-based form of inferentialmodeling, the three-dimensional collection of learned sequential patternmatrices D_(a)(t) can be understood as an aggregate matrix containinglearned sequential pattern matrices a to g that map to the sensor valuesin the input pattern array X_(in) and sequential pattern matrices a to gthat map to the inferred sensors D_(out)(t). Referring to FIG. 7,equation 9 is shown with an input pattern array X_(in) and athree-dimensional collection of learned sequential pattern matricesD_(in)(t) with seven learned sequential pattern matrices a to g for thefive input sensors 1 to 5. It is understood that the aggregate matrixD_(a)(t) is a three-dimensional extension of the two-dimensionalaggregate matrix defined in equation 10. Comparing the illustration inFIG. 7 to that in FIG. 6, the matrices within the brackets of bothfigures are identical except for how they are denoted. Therefore, thecalculation of the weight vector for an inferential model proceeds inthe same manner as that described above for an autoassociative model.Then, as in FIG. 4, the weight vector is multiplied by the learnedsequential pattern array for the inferred sensors in FIG. 7 except thathere matrix D_(out)(t) is now a three-dimensional collection of learnedsequential pattern matrices, and this step forms an estimate matrixx_(est) representing only the inferred sensors. As described above forthe vector-based form of inferential modeling, the weight vector canalso be multiplied by the full three-dimensional collection of learnedsequential pattern matrices D_(a)(t) that includes both D_(in)(t) andD_(out)(t) to generate estimate matrices for both input and inferredsensors (depicted in FIG. 8).

Inferential modeling enables calculation of estimates for sensors whosedata are not included in the input data stream because reference datafor these sensors are included in the three-dimensional collection oflearned sequential pattern matrices D_(a)(t) or D_(out)(t).Conceptually, an inferential model extrapolates along the dimension ofthe modeled sensors. It is also possible to create an inferential modelthat extrapolates in the time dimension. This can be understood byrevisiting the concept of the primary time point and the look-backwindow of equation 21. The time points in the look-back window precedethe primary time point, meaning that they lie in the past relative tothe primary time. One can also define a look-ahead window, constructedof time points that succeed the primary time. The time points in alook-ahead window are in the future relative to the primary time.Consider an ordered sequence of time points composed of a given number(n_(1b)) of time points that precede the primary time point and a givennumber (n_(1a)) of time points that succeed the primary time point:(t_(p)−n_(1b)Δt, t_(p)−(n_(1b)−1)Δt, t_(p)−2Δt, t_(p)−Δt, t_(p),t_(p)+Δt, t_(p)+2Δt, . . . , t_(p)+(n_(1a)−1)Δt, t_(p)+n_(1a)Δt). Thesequence of time points defines a pattern array that contains bothlook-back and look-ahead data,

$\begin{matrix}{{\overset{\leftrightarrow}{X}{f\left( t_{p} \right)}} = {\quad\begin{bmatrix}\begin{matrix}{{x\left( {t_{p} - {n_{1b}\Delta \; t}} \right)},{x\left( {t_{p} - {\left( {n_{1b} - 1} \right)\Delta \; t}} \right)},{\cdots \mspace{14mu} {x\left( {t_{p} - {2\Delta \; t}} \right)}},} \\{{x\left( {t_{p} - {\Delta \; t}} \right)},{x\left( t_{p} \right)},}\end{matrix} \\\begin{matrix}{{x\left( {t_{p} + {\Delta \; t}} \right)},{x\left( {t_{p} + {2\; \Delta \; t}} \right)},{\cdots \mspace{14mu} {x\left( {t_{p} + {\left( {n_{la} - 1} \right)\Delta \; t}} \right)}},} \\{x\left( {t_{p} + {n_{l_{a}}\Delta \; t}} \right)}\end{matrix}\end{bmatrix}}} & (29)\end{matrix}$

Referring to FIG. 9, an extension to the inferential form of SBM(equation 9) that supports extrapolation into the time dimension isproduced if the three-dimensional collection of learned sequentialpattern matrices D_(a)(t) is created with sequential pattern matrices ato g that contain both look-back and look-ahead data. Since the inputpattern array X_(in) contains data only from the current time point andpreceding time points (data from future time points do not exist yet),the collection of learned sequential pattern matrices D_(a)(t) is anaggregate matrix composed of two sub-matrices separated along the timedimension. The first of these sub-matrices D_(1b)(t) contains the datafrom the various primary time points and from the look-back time points.The second sub-matrix D_(1a)(t) contains the data from the look-aheadtime points. Equation 9 is shown with an input pattern array X_(in) offive input sensors and a look-back window of three time intervalsbetween the time points t_(p) to −3. The look-back portion or sub-matrixD_(1b)(t) is a three-dimensional collection of learned sequentialpattern matrices that contains data from five input sensors (1-5), sevenprimary time points each on its own sequential pattern matrix a to g,and four look-back time points or reference vectors t_(p) to −3 on eachsequential pattern matrix a to g. The look-ahead portion or sub-matrixD_(1a)(t) is a three-dimensional collection of learned sequentialpattern matrices that contains data from five input sensors (1-5), sevenlearned sequential pattern matrices a to g each with its own primarytime point, and two future or succeeding time points or vectors +1 and+2. The resulting weight vector, generated by the operations within thetwo sets of brackets, is multiplied by the look-ahead collection oflearned sequential pattern matrices D_(1a)(t) to create an estimatematrix Y_(1a) that extrapolates in time. In this example, twoextrapolated estimate vectors +1 and +2 are calculated for estimatematrix Y_(1a), representing the time points that are one and two timesteps Δt into the future. As described above with the vector-basedequation (FIG. 5), the weight vector can also be multiplied by the fullcollection of learned sequential pattern matrices D_(a)(t) that includesboth D_(1a)(t) and D_(1b)(t) to generate estimate matrices X_(1b) andY_(1a) within an estimate matrix XY_(e1) that contains estimate data forpast, current, and future time points (depicted in FIG. 10).

Comparing the illustrations in FIGS. 9 and 10 to those in FIGS. 7 and 8,the matrix calculations within the brackets of all four figures areidentical. This means that the calculation of the weight vector for aninferential model that extrapolates in the time dimension is identicalto that for an inferential model that extrapolates along the dimensionof the modeled sensors. The two forms of inferential modeling differonly by the data that are included in the full collection of learnedsequential pattern matrices. A model that includes data for time pointsthat are in the future relative to the primary time points extrapolatesinto the future. A model that includes data for sensors that are not inthe input data stream extrapolates into these sensors. Referring to FIG.11, an inferential model that extrapolates into both the time andmodeled sensor dimensions is shown. Its three-dimensional collection oflearned sequential pattern matrices D_(a)(t) is an aggregate matrixcomposed of four sub-matrices separated along the modeled sensor andtime dimensions. Its sub-matrices contain data for the look-back windowof the input sensors D_(1b)(t), data for the look-ahead window of theinput sensors D_(1a)(t), data for the look-back window of the output(inferred) sensors D_(1bout)(t), and data for the look-ahead window ofthe output (inferred) sensors D_(1aout)(t). The calculations generateestimate matrices X_(1b)and Y_(1a) within an estimate matrix XY_(e2)that contains estimate data for past, current, and future time points(depicted in FIG. 10) for both input and output (inferred) sensors.

Each of the various forms of kernel regression modeling with sequentialpattern arrays described above produces an estimate matrix of modelestimate data. In one example, estimate matrix X_(est) is formed foreach input pattern array X_(new) (FIG. 6). As understood from theexamples described above, in addition to the estimate vectorcorresponding to the current time point, the estimate matrix containsvectors for each of the time points in the look-back and/or look-aheadwindows. The number of sequential vectors in the estimate matrix dependson the form of the modeling equation (autoassociative or inferential)and the number of time points n_(1b) in the look-back window and thenumber of time points n_(1a) in the look-ahead window. As system timeprogresses, each fixed time point along the timeline accumulatesmultiple estimate vectors as the input pattern array reaches, movesthrough, and past the time point. The total number of estimate vectorsthat will be calculated for a fixed moment in time equals the totalnumber of sequential patterns (vectors) in the sequential pattern matrixand analyzed by the model. For an autoassociative model or aninferential model that extrapolates along the sensor dimension, thistotal number is given by n_(1b)+1, corresponding to an estimate vectorfor each pattern in the look-back window and an estimate vector for theprimary (current) time point. For an inferential model that extrapolatesalong the time dimension, this total number is given by n_(1b)+1+n_(1a),corresponding to an estimate vector for each pattern in the look-backand look-ahead windows and an estimate vector for the primary (current)time point.

Because multiple estimate vectors are calculated for a fixed point intime, utilizing sequential kernel regression models to feed algorithmsfor condition monitoring or diagnostics is complicated by the fact thatmany of these algorithms expect that only a single estimate vectorexists for a time point. The simplest means of dealing with the multipleestimate vectors is to simply designate less than all of the multiplevectors in the estimate matrix as the source of the model estimates andto ignore any others. In one form, only one of the estimate vectors fromeach estimate matrix is selected for further diagnostic analysis.Typically, this means that the estimate vector in the estimate matrixselected for a fixed, arbitrary point in time t_(i) while looking acrossmultiple estimate matrices is the one generated when that time pointbecomes the current time point (t_(i)=t_(cur)) or in other words, themost recent time point (t_(p) in the example estimate matrices of FIGS.6 to 8). As the input pattern window moves past t_(i), and t_(i) becomespart of the look-back window to the new current time point, new estimatedata calculated for t_(i) are ignored. In other words, the older orpreceding vectors relative to the current vector t_(p) in the estimatematrix are ignored.

Other, more complex methods can be used to produce or select a singleestimate vector for each fixed time point across multiple estimatematrices, while taking advantage of the information in the multiplevectors. Such methods include, but are not limited to, an average;weighted average; other weighted norms (2-norm and p-norm); maximum,minimum or median value, and so forth. The estimate vector chosen fordiagnostic analysis could also be the vector with the greatestsimilarity to its corresponding input vector, and may use a similarsimilarity equation as that used to determine the weight vector. It willalso be understood these methods can be applied to provide a singleestimate vector for each estimate matrix to represent multiplesequential time points within the estimate matrix rather than a singlefixed time point across multiple estimate matrices.

For an inferential model that extrapolates in the time dimension, aprognostic module 34 (FIG. 1) can use the future estimate matrix X_(1a)to feed prognostics algorithms, such as calculations of the remaininguseful life of an asset (or to state it another way, to determine thefuture condition or operational state of the object being monitored).This is based on the fact that the sequence of extrapolated estimates ofa modeled sensor is a trend-line that predicts the future behavior ofthe modeled sensor. As system time progresses and new input patternarrays are formed containing new primary vectors, new future estimatematrices are calculated. Like the other kernel regression modelsdescribed above, the new estimate matrices substantially overlapprevious matrices, meaning that multiple estimate values are producedfor each sensor at each time point.

Also similar to the other kernel regression models, the inferential timeextrapolating model can use various methods devised to reduce themultiple estimate values that are calculated at a fixed time point to asingle value suitable for trending of the sensor. The simplest method isto select the most-recently calculated estimate matrix to supply theestimate data at each of the time points in the look-ahead window.Specifically, for a fixed time point t_(i) well into the future, anestimate vector will be generated for it when the look-ahead patternwindow first reaches it: t_(i)=t_(cur)+n_(1a)*Δt. At each succeedingtime step as the look-ahead window passes through the fixed point, a newestimate vector is calculated for it, which replaces the last vector.Thus, all of the estimate vectors are used to build a trend line, andthe results for each time point (or fixed point) represented by estimatevectors are constantly being updated by the more recent estimate valuesto correspond to vectors as they past through the look-ahead window usedto build the estimate matrices.

Besides being simple, this approach produces sensor trends that reactquickly to dynamic changes since only the most-recently calculatedestimate matrix is used. Since estimate data in the trend-lines arereplaced for each succeeding time step, the trends are susceptible torandom fluctuations. This means that the trend value at a fixed timepoint can vary dramatically between successive time steps. Other morecomplex methods, such as average, weighted average, or other weightednorms, utilize two or more, or all, of the estimate values calculated ata fixed time point across multiple estimate matrices to produce a singleestimate value for it. Trend lines produced by these methods aresmoother, but less responsive to rapid dynamic changes. In addition tothe above methods, which are designed to produce trend-linesrepresentative of expected system behavior, other trend-lines can beproduced that indicate the range of possible behaviors. For instance, atrend-line that connects the maximum estimate values at each future timepoint coupled with a trend-line connecting the minimum estimate values,bound the results produced by the model.

Returning again to FIG. 1, the full estimate matrix X_(est) or a singlerepresentative estimate vector, as described above, is passed todifferencing engine 20. The differencing engine subtracts the estimatematrix from the input pattern array (X_(in) or X_(new)) or it subtractsthe representative estimate vector from the current time point's inputvector. Specifically, each selected estimate value from the estimatematrix is subtracted from a corresponding input value from the inputpattern array. This array of residual vectors or a single representativeresidual vector is then provided to the alert module 22. Alert module 22applies statistical tests to the residual data to determine whether theestimate and input data are statistically different. The alert module 22performs any of a variety of tests to make the fault determination. Thismay include a rules engine for assessing rules logic using one or moreresidual values. The rules can be of any of a variety of commonly usedrules, from simple univariate threshold measures, to multivariate and/ortime series logic. Furthermore, the output of some rules may be theinput to other rules, as for example when a simple threshold rule feedsinto a windowed alert counting rule (e.g., x threshold alerts in yobservations). Furthermore, statistical techniques may be used on theresidual data to derive other measures and signals, which themselves canbe input to the rules. Applicable statistical analyses can be selectedfrom a wide variety of techniques known in the art, including but notlimited to moving window statistics (means, medians, standarddeviations, maximum, minimum, skewness, kurtosis, etc.), statisticalhypothesis tests (for example, Sequential Probability Ratio Test(SPRT)), trending, and statistical process control (for example, CUSUM,S-chart).

The alert module 22 may determine that any differences between theestimate and input data is due to the normal operating conditions thatwere not encountered during training. In this case, sensor dataindicative of the new operating conditions are provided to the optionaladaptation module 30, which incorporates that data into the learning ofmodel 14 via library 18, for example. In addition, adaptation module 30may optionally perform its own automated tests on the data and/orresidual analysis results to determine which input vectors or inputarrays should be used to update the model 14.

The process of adapting a model comprises adding sensor data indicativeof the new operating conditions to the set of reference data in thelibrary H from which the original kernel-based model was “trained”. Inthe simplest embodiment, all reference data are used as the modelexemplars, and therefore adapting a model means adding the new sensordata to the exemplar set of the model. Since sequential kernelregression models operate on sequences of observation vectors by design,new operating data added to the reference data must consist of asequence of observation vectors. The minimum number of vectors addedduring any adaptation event equals the total number of sequentialpatterns (vectors) analyzed by the model. As described above, this totalnumber is given either by n_(1b)+1 for an autoassociative model or aninferential model that extrapolates along the sensor dimension, or byn_(1b)+1+n_(1a) for an inferential model that extrapolates along thetime dimension. If a training method has been used to down-select thereference observations to a subset stored as “representative” of systemdynamics as described above for forming the three-dimensional collectionof learned sequential pattern matrices D(t), then the new sequence ofobservation vectors (or in other words the entire input pattern array)is added to the original reference dataset, and the down-selectiontechnique is applied to derive a new representative exemplar set, whichshould then include representation of the new observations. It is alsopossible to merely add the new sequence to a down-selected set oflearned pattern arrays, without rerunning the down-selection technique.Furthermore, in that case, it may be useful to remove some learnedpattern arrays from the model so that they are effectively replaced bythe new data, and the model is kept at a manageable size. The criteriafor which old learned pattern arrays are removed can include clusteringand similarity determinations using equations described above whichcompare the observations at the new primary time points to theobservations at old primary time points and replace those sequentialpattern arrays most like the new sequential pattern arrays.

To this point, the invention describes sequential kernel regressionmodels that are trained with representative data from periods of normaloperation. It has been shown that such models can be used to detect anddiagnosis system faults. In addition, the time-inferential form of theinvention produces models that can extrapolate system behavior into thefuture. But since the models are trained only with normal operatingdata, their utility as a fault progresses is limited as the systembehavior departs further and further from normality.

To improve diagnostics and prognostics during developing faults,separate sequential kernel regression models that are trained with datacollected during fault conditions (or failure mode reference data) canbe utilized. These fault models are activated only after there is anindication that a fault is developing in the system. The faultindication can be provided by sequential models trained with normalsystem data, or by numerous other means; including, but not limited to,vector-based kernel regression models (for example, SBM), neuralnetworks, k-means clustering models, and rule-based fault detectionmodels. The fault models are trained with full transient histories ofknown fault events for the asset being monitored. These fault eventsneed not have occurred on the actual asset from an earlier period intime, they can come from fault events that have occurred on othermachinery that are substantially equivalent to the asset beingmonitored. The fault histories consist of all system data collected fromthe time at which the fault was first indicated to the final end stateof the event, such as system failure or system shutdown.

It will be appreciated by those skilled in the art that modifications tothe foregoing embodiments may be made in various aspects. Othervariations clearly would also work, and are within the scope and spiritof the invention. The present invention is set forth with particularityin the appended claims. It is deemed that the spirit and scope of thatinvention encompasses such modifications and alterations to theembodiments herein as would be apparent to one of ordinary skill in theart and familiar with the teachings of the present application.

What is claimed is:
 1. A monitoring system for determining the futureoperational condition of an object, comprising: an empirical modelmodule configured to: receive reference data that indicates the normaloperational state of the object, receive input multi-dimensional patternarrays, each input pattern array having a plurality of input vectors,each input vector representing a time point and having input valuesrepresenting a plurality of parameters indicating the condition of theobject obtained from one or more first sensors at any time, each inputvector arranged and maintained in a predetermined and time orderedrelationship with the others, and generate estimate values based on acalculation that uses an input pattern array and the reference data todetermine a similarity measure between the input values and referencedata, the similarity measure accounting for the predetermined andordered time relationship. wherein the estimate values are in the formof an estimate matrix that includes at least one estimate vector ofinferred estimate values for at least one future point in time or aplurality of second sensors being different from the one or more firstsensors, each estimate vector arranged and maintained in thepredetermined and ordered time relationship with the others, thereference data being grouped in multi-dimensional training arraysincluding reference vectors, such that each reference vector in anytraining array is arranged and maintained in the predetermined andordered time relationship with the others and such that the generationdoes not destroy any time information of the estimate matrix or thereference data; and a diagnostic module configured to use the inferredestimate values to determine a current outcome of the object.
 2. Thesystem of claim 1 further comprising a prognostic module configured touse the inferred estimate values to determine a future condition of theobject.
 3. The system of claim 1 wherein the estimate matrices onlyinclude estimate vectors that represent time points that are notrepresented by the input vectors.
 4. The system of claim 1 wherein theestimate matrices include at least one estimate vector that representsthe same time point represented by the input vectors and at least oneestimate vector that represents a time point that is not represented bythe input vectors.
 5. The system of claim 1 wherein the estimatematrices include estimate values that represent parameters that indicatethe condition of the object and that are not represented by the inputvalues.
 6. The system of claim 1 wherein each estimate matrix representsa primary current time point and time points not represented by theinput vectors and that are succeeding time points relative to thecurrent time point.
 7. The system of claim 1 wherein the empiricalmodule is configured to generate weight values by using the similaritymeasures, and uses the weight values in a calculation with the referencedata to generate the estimate matrix.
 8. The system of claim 7 whereinthe weights values are in the form of a weight vector.
 9. The system ofclaim 7 wherein the reference data used in the calculation with weightvalues comprises reference values that represent time points that arenot represented by the input pattern arrays.
 10. The system of claim 9wherein the reference data used in the calculation with weight valuesrepresents a primary current time point and the time points notrepresented by the input vectors are succeeding time points relative tothe current time point.
 11. The system of claim 7 wherein the referencedata used in the calculation with the weight values is in the form of athree-dimensional collection of learned sequential pattern matrices,each learned sequential pattern matrix comprising reference vectors ofreference values, wherein each reference vector represents a differenttime point within the learned sequential pattern matrix.
 12. The systemof claim 11 wherein each learned sequential pattern matrix comprises aprimary current time point and time points that represent succeedingtime points relative to the primary current time point and that are notrepresented by the input pattern arrays.
 13. The system of claim 1wherein the same time point is represented in multiple estimatematrices.
 14. The system of claim 2 wherein the prognostic module isconfigured to use the most recent estimate matrix to update the estimatevalues for use to determine the condition of the object.
 15. The systemof claim 2 wherein the prognostic module is configured to provide valuesfor a single estimate vector to represent a single time point acrossmultiple estimate matrices.
 16. The system of claim 15 wherein thesingle estimate vector is an average, a weighted average, or a weightednorm of all of the estimate vectors at the single time point.
 17. Thesystem of claim 2 wherein the prognostic module is configured to providevalues for a single estimate vector to represent each estimate matrix.18. The system of claim 17 wherein the single estimate vector is anaverage, weighted average, or weighted norm of the estimate vectorswithin the estimate matrix.
 19. The system of claim 2 wherein theprognostic module is configured to form a trend line for at least oneparameter represented by the inferred estimate values to indicate theexpected behavior of the object.
 20. The system of claim 19 wherein theprognostic module is configured to form a new trend line with each newestimate matrix.
 21. The system of claim 19 wherein the prognosticmodule is configured to form boundary trend lines to define a range ofexpected behavior of the object.
 22. The system of claim 19 wherein theprognostic module is configured to form an upper boundary trend linewith maximum estimate values from the time points, and a lower boundarytrend line with minimum estimate values from the time points.